﻿using AutoMapper;
using Microsoft.EntityFrameworkCore;
using PowerManage.Entity;
using PowerManage.Entity.Dtos.Accounts;
using PowerManage.Entity.Dtos.Permissions;
using PowerManage.Repository;

namespace PowerManage.Service.Impl;

/**
 * 角色权限
 */
public class RolePermissionService : BaseService, IRolePermissionService
{
    private readonly IBaseRepository<ElePermission> _permissionRepository;
    private readonly IBaseRepository<EleRolePermission> _rolePermissionRepository;
    private readonly IBaseRepository<EleRole> _roleRepository;
    private readonly IMapper _mapper;

    public RolePermissionService(IMapper mapper, IBaseRepository<ElePermission> permissionRepository,
        IBaseRepository<EleRolePermission> rolePermissionRepository, IBaseRepository<EleRole> roleRepository)
    {
        _mapper = mapper;
        _permissionRepository = permissionRepository;
        _rolePermissionRepository = rolePermissionRepository;
        _roleRepository = roleRepository;
    }

    /// <summary>
    /// 获取角色权限列表
    /// </summary>
    /// <param name="roleName"></param>
    /// <returns></returns>
    public async Task<List<AccountPermissionsDto>> GetRolePermissions(string roleName)
    {
        //根据角色名获取角色权限列表
        //join中的参数：
        // firstSequence：第一个序列。
        // secondSequence：第二个序列。
        // firstKeySelector：选择第一个序列中的键。
        // secondKeySelector：选择第二个序列中的键。
        // resultSelector：选择最终结果。
        // equalityComparer：可选参数，用于比较键是否相等，默认使用默认的比较器。
        // var permissions = await _DbContext.Set<ElePermission>()
        //     .Join(_DbContext.Set<EleRolePermission>(), permission => permission.Id,
        //         rolePermission => rolePermission.PermissionId,
        //         ((permission, rolePermission) =>
        //             //这个匿名对象用于组合两个表中的记录，并作为后续查询的基础
        //             new { ElePermission = permission, EleRolePermission = rolePermission }))
        //     .Join(_DbContext.Set<EleRole>(), rolePermission => rolePermission.EleRolePermission.RoleId, role => role.Id,
        //         (rolePermission, role) => new { EleRolePermission = rolePermission.ElePermission, EleRole = role })
        //     .Where(rolePermission => rolePermission.EleRole.Name == roleName)
        //     .Select(rolePermission => rolePermission.EleRolePermission)
        //     .ToListAsync();
        var permissions = await (from p in _permissionRepository.GetQueryable()
                join rp in _rolePermissionRepository.GetQueryable() on p.Id equals rp.PermissionId
                join r in _roleRepository.GetQueryable() on rp.RoleId equals r.Id
                where r.Name == roleName
                select p
            ).ToListAsync();
        //对象映射转化
        var accountPermissionsDtos = _mapper.Map<List<AccountPermissionsDto>>(permissions);
        return accountPermissionsDtos;
    }

    /// <summary>
    /// 获取角色权限列表
    /// </summary>
    /// <param name="roleId"></param>
    /// <returns></returns>
    public async Task<List<PermissionDto>> GetRolePermissions(long roleId)
    {
        // 初始化权限数据传输对象列表
        var permissionDtos = new List<PermissionDto>();

        // 根据角色ID获取角色权限
        var rolePermissions = await _rolePermissionRepository.GetQueryable()
            .Where(x => x.RoleId == roleId) // 过滤出角色ID与当前角色匹配的角色权限
            .ToListAsync(); // 异步获取所有匹配的角色权限列表

        // 遍历角色权限列表，获取每个权限详情
        foreach (var rolePermission in rolePermissions)
        {
            // 根据权限ID获取权限详情
            var permission =
                await _permissionRepository.GetQueryable()
                    .FirstOrDefaultAsync(x => x.Id == rolePermission.PermissionId); // 异步获取第一个匹配的权限或默认值

            // 将权限实体映射为权限数据传输对象
            var permissionDto = _mapper.Map<PermissionDto>(permission);

            // 将权限数据传输对象添加到列表中
            permissionDtos.Add(permissionDto);
        }

        // 返回权限数据传输对象列表
        return permissionDtos;
    }

    /// <summary>
    /// 更改角色的权限列表
    /// </summary>
    /// <param name="roleId"></param>
    /// <param name="permissionIds"></param>
    /// <param name="userId"></param>
    /// <returns></returns>
    public async Task<bool> UpdateRolePermissions(long roleId, List<long> permissionIds, long userId)
    {
        // 删除当前角色的所有权限，以确保权限的更新是全新的，而不是增量的
        await _rolePermissionRepository.GetQueryable().Where(x => x.RoleId == roleId).ExecuteDeleteAsync();
        // 初始化一个列表来存储新的角色权限关系
        var eleRolePermissions = new List<EleRolePermission>();
        // 遍历权限ID列表，为每个权限创建一个新的角色权限对象，并添加到列表中
        foreach (var permissionId in permissionIds)
        {
            var eleRolePermission = new EleRolePermission();
            // 设置角色权限对象的属性
            eleRolePermission.RoleId = roleId;
            eleRolePermission.PermissionId = permissionId;
            eleRolePermission.CreationTime = DateTime.Now;
            eleRolePermission.CreatorId = userId;
            // 将角色权限对象添加到列表中
            eleRolePermissions.Add(eleRolePermission);
        }

        // 将列表中的所有角色权限对象添加到数据库中
        var result = _rolePermissionRepository.AddRange(eleRolePermissions);
        // 返回是否成功保存了任何实体到数据库中
        return result > 0;
    }
}